var express = require('express');
const puppeteer = require('puppeteer');
var router = express.Router();
const axios = require('axios');
const fs = require('fs'); // 新增：引入文件系统模块
const path = require('path'); // 新增：引入路径处理模块
const {UserRole, Permission, User, Role, UserPermission, RolePermission,Course,StudentList} = require('../mongoDB/index');
// 登录
router.post('/login',async (req, res) => {
  const { username, password } = req.body;
  const user = await User.findOne({ username, password });
  if (user) {
    const userRoles = await UserRole.findOne({ user_id: user._id })
    res.json({
      code: 200,
      message: '登录成功',
      data: userRoles,
      user: user
    })
  } else {
    res.json({
      code: 400,
      message: '用户名或密码错误'
    });
  }
});

// 获取所有用户
router.get('/users', async (req, res) => {
  try {
    const users = await User.find();
    res.json({ code: 200, data: users });
  } catch (err) {
    res.status(500).json({ code: 500, message: '获取用户失败', error: err.message });
  }
});

// 创建新角色
router.post('/roles', async (req, res) => {
  const { role_name, description } = req.body;
  try {
    const newRole = await Role.create({ role_name, description });
    res.json({ code: 200, message: '角色创建成功', data: newRole });
  } catch (err) {
    res.status(400).json({ code: 400, message: '角色创建失败（名称可能重复）', error: err.message });
  }
});

// 获取某个角色的权限列表
router.get('/role-permissions/:roleId', async (req, res) => {
  const { roleId } = req.params;
  try {
    const rolePermissions = await RolePermission.find({ role_id: roleId }).populate('permission_id');
    const permissions = rolePermissions.map(item => item.permission_id);// 取出权限ID数组
    res.json({ code: 200, data: permissions });
  } catch (err) {
    res.status(500).json({ code: 500, message: '获取角色权限失败', error: err.message });
  }
});

// 为用户直接分配权限（UserPermission）
router.post('/user-permissions', async (req, res) => {
  const { user_id, permission_id } = req.body;
  try {
    const newUserPermission = await UserPermission.create({ user_id, permission_id });
    res.json({ code: 200, message: '用户权限分配成功', data: newUserPermission });
  } catch (err) {
    res.status(400).json({ code: 400, message: '权限分配失败（可能已存在）', error: err.message });
  }
});



// 课程列表
router.get('/courses', async (req, res) => {
  const {course_name}=req.query
  const obj={}
  // if(course_name){
  //   // 模糊查询
  //   obj.course_name=
  // }
  try {
    const courses = await Course.find(obj)
    res.json({ code: 200, data: courses });
  } catch (err) {
    res.status(500).json({ code: 500, message: '获取课程失败', error: err.message });
  }
});

// 学生列表
router.get('/students', async (req, res) => {
  try {
    const students = await StudentList.find();
    res.json({ code: 200, data: students });
  } catch (err) {
    res.status(500).json({ code: 500, message: '获取学生失败', error: err.message });
  }
});

// 截图学生列表（关键接口）
router.get('/screenshot/students', async (req, res) => {
  let browser; 
  let tempFilePath; // 关键修改：将 tempFilePath 声明在 try 块外部
  try {
    // 1. 启动无头浏览器（关键配置）
    browser = await puppeteer.launch({
      headless: 'new', 
      args: ['--no-sandbox', '--disable-setuid-sandbox'], 
      defaultViewport: { width: 1200, height: 800 } 
    });

    // 2. 创建新页面
    const page = await browser.newPage();

    // 3. 获取学生数据（从你的 MongoDB 接口）
    const studentResponse = await axios.get('http://localhost:3000/students');
    const students = studentResponse.data.data; 

    // 4. 生成临时 HTML（关键：将数据渲染为 HTML）
    const htmlContent = `
      <!DOCTYPE html>
      <html>
        <head>
          <meta charset="UTF-8">
          <style>
            table { width: 100%; border-collapse: collapse; }
            th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }
            th { background-color: #f2f2f2; }
          </style>
        </head>
        <body>
          <h1>学生列表（截图时间：${new Date().toLocaleString()}）</h1>
          <table>
            <tr>
              <th>姓名</th>
              <th>学号</th>
            </tr>
            ${students.map(student => `
              <tr>
                <td>${student.student_name}</td>
                <td>${student.student_id}</td>
              </tr>
            `).join('')}
          </table>
        </body>
      </html>
    `;

    // 5. 写入临时 HTML 文件（关键修改：赋值给外部声明的 tempFilePath）
    tempFilePath = path.join(__dirname, 'temp_student_list.html');
    fs.writeFileSync(tempFilePath, htmlContent);

    // 6. 导航到临时 HTML（本地文件协议）
    await page.goto(`file://${tempFilePath}`, {
      waitUntil: 'networkidle0', // 等待网络无请求（确保 CSS/JS 加载完成）
      timeout: 30000 // 导航超时 30 秒
    });

    // 7. 等待页面渲染完成（可选：根据实际需要调整等待逻辑）
    await page.waitForSelector('table', { timeout: 5000 }); // 等待表格渲染

    // 8. 截图（完整页面）
    const screenshotBuffer = await page.screenshot({
      fullPage: true, // 自动滚动截取完整内容
      type: 'png' // 保留 PNG 格式（无需 quality 参数）
    });

    // 9. 返回截图（或保存到本地）
    res.setHeader('Content-Type', 'image/png');
    res.send(screenshotBuffer);

  } catch (err) {
    // 错误处理（关键：记录日志并返回友好提示）
    console.error('截图失败:', err);
    res.status(500).json({ 
      code: 500, 
      message: '截图失败，请检查数据或联系管理员', 
      error: err.message 
    });
  } finally {
    // 10. 清理资源（关键：避免内存泄漏）
    if (browser) await browser.close(); // 关闭浏览器
    if (fs.existsSync(tempFilePath)) fs.unlinkSync(tempFilePath); // 删除临时文件
  }
});

// 添加课程（原有接口保持不变）
router.post('/courses', async (req, res) => {
  const { course_name, course_desc, course_teacher } = req.body;
  try {
    const newCourse = await Course.create({ course_name, course_desc, course_teacher });
    res.json({ code: 200, message: '课程添加成功', data: newCourse });
  } catch (err) {
    res.status(400).json({ code: 400, message: '课程添加失败', error: err.message });
  }
});

// 新增：修改课程接口（PUT请求）
router.put('/courses/:id', async (req, res) => {
  const { id } = req.params;
  const { course_name, course_desc, course_teacher } = req.body;
  try {
    const updatedCourse = await Course.findByIdAndUpdate(
      id,
      { course_name, course_desc, course_teacher },
      { new: true, runValidators: true } // 返回更新后的文档并验证字段
    );
    if (!updatedCourse) {
      return res.status(404).json({ code: 404, message: '未找到该课程' });
    }
    res.json({ code: 200, message: '课程修改成功', data: updatedCourse });
  } catch (err) {
    res.status(400).json({ code: 400, message: '课程修改失败', error: err.message });
  }
});

// 添加学生
router.post('/students', async (req, res) => {
  const { student_name, student_age, student_gender, student_course } = req.body;
  try {
    const newStudent = await StudentList.create({ student_name, student_age, student_gender, student_course });
    res.json({ code: 200, message: '学生添加成功', data: newStudent });
  } catch (err) {
    res.status(400).json({ code: 400, message: '学生添加失败', error: err.message });
  }
});

// 新增：修改学生接口（PUT请求）
router.put('/students/:id', async (req, res) => {
  const { id } = req.params;
  const { student_name, student_age, student_gender, student_course } = req.body;
  try {
    const updatedStudent = await StudentList.findByIdAndUpdate(
      id,
      { student_name, student_age, student_gender, student_course },
      { new: true, runValidators: true } // 返回更新后的文档并验证字段
    );
    if (!updatedStudent) {
      return res.status(404).json({ code: 404, message: '未找到该学生' });
    }
    res.json({ code: 200, message: '学生信息修改成功', data: updatedStudent });
  } catch (err) {
    res.status(400).json({ code: 400, message: '学生信息修改失败', error: err.message });
  }
});

// 新增：删除学生接口（DELETE请求）
router.delete('/students/:id', async (req, res) => {
  const { id } = req.params;
  try {
    const deletedStudent = await StudentList.findByIdAndDelete(id);
    if (!deletedStudent) {
      return res.status(404).json({ code: 404, message: '未找到该学生' });
    }
    res.json({ code: 200, message: '学生删除成功', data: deletedStudent });
  } catch (err) {
    res.status(400).json({ code: 400, message: '学生删除失败', error: err.message });
  }
});

// 新增：删除课程接口（DELETE请求）
router.delete('/courses/:id', async (req, res) => {
  const { id } = req.params;
  try {
    const deletedCourse = await Course.findByIdAndDelete(id);
    if (!deletedCourse) {
      return res.status(404).json({ code: 404, message: '未找到该课程' });
    }
    res.json({ code: 200, message: '课程删除成功', data: deletedCourse });
  } catch (err) {
    res.status(400).json({ code: 400, message: '课程删除失败', error: err.message });
  }
});

// 原有默认路由（保持不变）
router.get('/', function(req, res, next) {
  res.render('index', { title: 'Express' });
});

module.exports = router;

